package org.dxy.trigger.http;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dxy.api.dto.request.unit.CreateUnitManageRequest;
import org.dxy.api.dto.request.unit.UpdateUnitManageRequest;
import org.dxy.api.dto.response.R;
import org.dxy.infrastructure.persistent.po.UnitManagePo;
import org.dxy.trigger.http.service.UnitManageApplicationService;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @description: 单位管理控制器
 * @author: dxy
 * @createTime: 2025/1/21
 */
@Slf4j
@RestController
@RequestMapping("/api/unit-manage")
@RequiredArgsConstructor
public class UnitManageController {
    
    private final UnitManageApplicationService unitManageApplicationService;

    /**
     * 创建单位
     * @param dto 单位创建请求DTO
     * @return 操作结果
     */
    @PostMapping("/create")
    public R<Long> create(@Validated @RequestBody CreateUnitManageRequest dto) {
        log.info("创建单位请求 - 单位编码: {}, 单位名称: {}", dto.getUnitCode(), dto.getUnitName());
        
        try {
            R<Long> result = unitManageApplicationService.create(dto);
            if (result.isOk()) {
                log.info("单位创建成功 - 单位编码: {}, ID: {}", dto.getUnitCode(), result.getData());
            } else {
                log.warn("单位创建失败 - 单位编码: {}, 错误信息: {}", dto.getUnitCode(), result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("单位创建异常 - 单位编码: {}", dto.getUnitCode(), e);
            return R.fail("单位创建失败: " + e.getMessage());
        }
    }

    /**
     * 更新单位
     * @param dto 单位更新请求DTO
     * @return 操作结果
     */
    @PutMapping("/update")
    public R<Void> update(@Validated @RequestBody UpdateUnitManageRequest dto) {
        log.info("更新单位请求 - ID: {}, 单位编码: {}", dto.getId(), dto.getUnitCode());
        
        try {
            R<Void> result = unitManageApplicationService.update(dto);
            if (result.isOk()) {
                log.info("单位更新成功 - ID: {}", dto.getId());
            } else {
                log.warn("单位更新失败 - ID: {}, 错误信息: {}", dto.getId(), result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("单位更新异常 - ID: {}", dto.getId(), e);
            return R.fail("单位更新失败: " + e.getMessage());
        }
    }

    /**
     * 分页查询单位列表
     * @param page 分页参数
     * @param query 查询条件
     * @return 分页的单位列表
     */
    @GetMapping("/list")
    public R<Page<UnitManagePo>> list(
            @ParameterObject Page<UnitManagePo> page,
            @ParameterObject UnitManagePo query) {
        log.info("分页查询单位列表 - 页码: {}, 每页大小: {}", page.getCurrent(), page.getSize());
        
        try {
            R<Page<UnitManagePo>> result = unitManageApplicationService.list(page, query);
            if (result.isOk()) {
                log.info("单位列表查询成功 - 总数: {}", result.getData().getTotal());
            }
            return result;
        } catch (Exception e) {
            log.error("单位列表查询异常", e);
            return R.fail("单位列表查询失败: " + e.getMessage());
        }
    }

    /**
     * 查询单位详情
     * @param id 单位ID
     * @return 单位详情
     */
    @GetMapping("/{id}")
    public R<UnitManagePo> getById(@PathVariable Long id) {
        log.info("查询单位详情 - ID: {}", id);
        
        if (id == null || id <= 0) {
            log.warn("无效的单位ID: {}", id);
            return R.fail("单位ID不能为空且必须为正整数");
        }
        
        try {
            R<UnitManagePo> result = unitManageApplicationService.getById(id);
            if (result.isOk()) {
                log.info("单位详情查询成功 - ID: {}", id);
            } else {
                log.warn("单位详情查询失败 - ID: {}, 错误信息: {}", id, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("单位详情查询异常 - ID: {}", id, e);
            return R.fail("单位详情查询失败: " + e.getMessage());
        }
    }

    /**
     * 根据单位编码查询单位
     * @param unitCode 单位编码
     * @return 单位详情
     */
    @GetMapping("/code/{unitCode}")
    public R<UnitManagePo> getByUnitCode(@PathVariable String unitCode) {
        log.info("根据单位编码查询单位 - 编码: {}", unitCode);
        
        if (unitCode == null || unitCode.trim().isEmpty()) {
            log.warn("单位编码不能为空");
            return R.fail("单位编码不能为空");
        }
        
        try {
            R<UnitManagePo> result = unitManageApplicationService.getByUnitCode(unitCode);
            if (result.isOk()) {
                log.info("单位查询成功 - 编码: {}", unitCode);
            } else {
                log.warn("单位查询失败 - 编码: {}, 错误信息: {}", unitCode, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("单位查询异常 - 编码: {}", unitCode, e);
            return R.fail("单位查询失败: " + e.getMessage());
        }
    }

    /**
     * 获取所有启用的单位（用于下拉选择）
     * @return 单位列表
     */
    @GetMapping("/all-enabled")
    public R<List<UnitManagePo>> getAllEnabled() {
        log.info("获取所有启用的单位");
        
        try {
            R<List<UnitManagePo>> result = unitManageApplicationService.getAllEnabled();
            if (result.isOk()) {
                log.info("获取所有启用单位成功 - 数量: {}", result.getData().size());
            }
            return result;
        } catch (Exception e) {
            log.error("获取所有启用单位异常", e);
            return R.fail("获取所有启用单位失败: " + e.getMessage());
        }
    }

    /**
     * 根据单位类型查询单位
     * @param unitType 单位类型
     * @return 单位列表
     */
    @GetMapping("/type/{unitType}")
    public R<List<UnitManagePo>> getByUnitType(@PathVariable String unitType) {
        log.info("根据单位类型查询单位 - 单位类型: {}", unitType);
        
        try {
            R<List<UnitManagePo>> result = unitManageApplicationService.getByUnitType(unitType);
            if (result.isOk()) {
                log.info("根据单位类型查询单位成功 - 单位类型: {}, 数量: {}", unitType, result.getData().size());
            }
            return result;
        } catch (Exception e) {
            log.error("根据单位类型查询单位异常 - 单位类型: {}", unitType, e);
            return R.fail("根据单位类型查询单位失败: " + e.getMessage());
        }
    }

    /**
     * 删除单位
     * @param id 单位ID
     * @return 操作结果
     */
    @DeleteMapping("/{id}")
    public R<Void> delete(@PathVariable Long id) {
        log.info("删除单位请求 - ID: {}", id);
        
        if (id == null || id <= 0) {
            log.warn("无效的单位ID: {}", id);
            return R.fail("单位ID不能为空且必须为正整数");
        }
        
        try {
            R<Void> result = unitManageApplicationService.delete(id);
            if (result.isOk()) {
                log.info("单位删除成功 - ID: {}", id);
            } else {
                log.warn("单位删除失败 - ID: {}, 错误信息: {}", id, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("单位删除异常 - ID: {}", id, e);
            return R.fail("单位删除失败: " + e.getMessage());
        }
    }

    /**
     * 获取所有基础单位
     * @return 基础单位列表
     */
    @GetMapping("/base-units")
    public R<List<UnitManagePo>> getBaseUnits() {
        log.info("获取所有基础单位");
        
        try {
            R<List<UnitManagePo>> result = unitManageApplicationService.getBaseUnits();
            if (result.isOk()) {
                log.info("获取基础单位成功 - 数量: {}", result.getData().size());
            }
            return result;
        } catch (Exception e) {
            log.error("获取基础单位异常", e);
            return R.fail("获取基础单位失败: " + e.getMessage());
        }
    }

    /**
     * 根据单位类型获取基础单位
     * @param unitType 单位类型
     * @return 基础单位列表
     */
    @GetMapping("/base-units/type/{unitType}")
    public R<List<UnitManagePo>> getBaseUnitsByType(@PathVariable String unitType) {
        log.info("根据单位类型获取基础单位 - 单位类型: {}", unitType);
        
        try {
            R<List<UnitManagePo>> result = unitManageApplicationService.getBaseUnitsByType(unitType);
            if (result.isOk()) {
                log.info("根据单位类型获取基础单位成功 - 单位类型: {}, 数量: {}", unitType, result.getData().size());
            }
            return result;
        } catch (Exception e) {
            log.error("根据单位类型获取基础单位异常 - 单位类型: {}", unitType, e);
            return R.fail("根据单位类型获取基础单位失败: " + e.getMessage());
        }
    }

    /**
     * 批量删除单位
     * @param ids 单位ID列表
     * @return 操作结果
     */
    @DeleteMapping("/batch")
    public R<Void> batchDelete(@RequestBody List<Long> ids) {
        log.info("批量删除单位请求 - ID列表: {}", ids);
        
        if (ids == null || ids.isEmpty()) {
            log.warn("批量删除请求参数无效: ID列表为空");
            return R.fail("单位ID列表不能为空");
        }
        
        // 验证ID列表中的每个ID都是有效的正整数
        for (Long id : ids) {
            if (id == null || id <= 0) {
                log.warn("批量删除请求参数无效: 包含无效的单位ID {}", id);
                return R.fail("单位ID列表中包含无效的ID: " + id);
            }
        }
        
        if (ids.size() > 100) {
            log.warn("批量删除请求参数无效: 一次删除的单位数量过多 {}", ids.size());
            return R.fail("一次最多只能删除100个单位");
        }
        
        try {
            R<Void> result = unitManageApplicationService.batchDelete(ids);
            if (result.isOk()) {
                log.info("批量删除单位成功 - 删除数量: {}", ids.size());
            } else {
                log.warn("批量删除单位失败 - ID列表: {}, 错误信息: {}", ids, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("批量删除单位异常 - ID列表: {}", ids, e);
            return R.fail("批量删除单位失败: " + e.getMessage());
        }
    }
}